home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / progtool / c / egem / source / graf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-22  |  9.8 KB  |  449 lines
  1.  
  2. #include <time.h>
  3. #include "proto.h"
  4.  
  5. static EVENT event =
  6. { 0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,{0,0,0,0,0,0,0,0} };
  7.  
  8. static void draw_rubber(int *);
  9.  
  10. static int mouse_index;
  11. static long last_mouse;
  12.  
  13. static MFORM mouse_form[4] = {
  14. { 7,7,1,0,1,
  15.   {0x03C0, 0x0FF0, 0x1FF8, 0x3FFC, 0x7FFE, 0x7FFE, 0xFFFF, 0xFFFF, 
  16.    0xFFFF, 0xFFFF, 0x7FFE, 0x7FFE, 0x3FFC, 0x1FF8, 0x0FF0, 0x03C0},
  17.   {0x0000, 0x03C0, 0x0CF0, 0x10F8, 0x20FC, 0x20FC, 0x40FE, 0x40FE, 
  18.    0x7F02, 0x7F02, 0x3F04, 0x3F04, 0x1F08, 0x0F30, 0x03C0, 0x0000}},
  19. { 7,7,1,0,1,
  20.   {0x03C0, 0x0FF0, 0x1FF8, 0x3FFC, 0x7FFE, 0x7FFE, 0xFFFF, 0xFFFF, 
  21.    0xFFFF, 0xFFFF, 0x7FFE, 0x7FFE, 0x3FFC, 0x1FF8, 0x0FF0, 0x03C0},
  22.   {0x0000, 0x03C0, 0x0C30, 0x1008, 0x381C, 0x3C3C, 0x7E7E, 0x7FFE, 
  23.    0x7FFE, 0x7E7E, 0x3C3C, 0x381C, 0x1008, 0x0C30, 0x03C0, 0x0000}},
  24. { 7,7,1,0,1,
  25.   {0x03C0, 0x0FF0, 0x1FF8, 0x3FFC, 0x7FFE, 0x7FFE, 0xFFFF, 0xFFFF, 
  26.    0xFFFF, 0xFFFF, 0x7FFE, 0x7FFE, 0x3FFC, 0x1FF8, 0x0FF0, 0x03C0},
  27.   {0x0000, 0x03C0, 0x0F30, 0x1F08, 0x3F04, 0x3F04, 0x7F02, 0x7F02, 
  28.    0x40FE, 0x40FE, 0x20FC, 0x20FC, 0x10F8, 0x0CF0, 0x03C0, 0x0000}},
  29. { 7,7,1,0,1,
  30.   {0x03C0, 0x0FF0, 0x1FF8, 0x3FFC, 0x7FFE, 0x7FFE, 0xFFFF, 0xFFFF, 
  31.    0xFFFF, 0xFFFF, 0x7FFE, 0x7FFE, 0x3FFC, 0x1FF8, 0x0FF0, 0x03C0},
  32.   {0x0000, 0x03C0, 0x0FF0, 0x1FF8, 0x2FF4, 0x27E4, 0x43C2, 0x4182, 
  33.    0x4182, 0x43C2, 0x27E4, 0x2FF4, 0x1FF8, 0x0FF0, 0x03C0, 0x0000}}};
  34.  
  35. void graf_busy_mouse(void)
  36. {
  37.     long time;
  38.  
  39.     if (((time=clock())-last_mouse)<20)
  40.         return;
  41.  
  42.     last_mouse = time;
  43.     graf_mouse(USER_DEF,&mouse_form[mouse_index++]);
  44.     mouse_index &= 3;
  45. }
  46.  
  47. void graf_rt_slidebox(SLINFO *sl,int obj,int double_click)
  48. {
  49.     reg DIAINFO *info = sl->sl_info;
  50.     reg OBJECT *ptree = info->di_tree;
  51.     reg OBJECT *ob_ptr = ptree+sl->sl_slider,*par_ptr = ptree+sl->sl_parent;
  52.     reg int pos,prev,max_pos,max_val;
  53.     reg long y;
  54.     int    top,start_x,start_y,delta,events,flag = 0,count,index,offset = 0,dummy;
  55.     boolean sl_mode;
  56.     GRECT par;
  57.  
  58.     if (info->di_flag>=WINDOW)
  59.     {
  60.         wind_xget(0,WF_TOP,&top,&dummy,&dummy,&dummy);
  61.         top = (top==info->di_handle);
  62.     }
  63.     else
  64.         top = TRUE;
  65.  
  66.     start_x = ob_ptr->ob_x;
  67.     start_y = ob_ptr->ob_y;
  68.  
  69.     if ((max_val = sl->sl_max - sl->sl_page)<0)
  70.         max_val = 0;
  71.  
  72.     if (obj==sl->sl_dec || obj==sl->sl_inc)
  73.     {
  74.         sl_mode = TRUE;
  75.         count = index = 0;
  76.         if (obj==sl->sl_dec)
  77.             sl->sl_dec = FAIL;
  78.         else
  79.             sl->sl_inc = FAIL;
  80.     }
  81.     else if (obj==sl->sl_slider)
  82.     {
  83.         _mouse_pos(&event.ev_mm1x, &event.ev_mm1y);
  84.         start_x -= event.ev_mm1x;
  85.         start_y -= event.ev_mm1y;
  86.         sl_mode = FAIL;
  87.     }
  88.     else
  89.     {
  90.         _mouse_pos(&start_x, &start_y);
  91.         sl_mode = FALSE;
  92.     }
  93.  
  94.     objc_offset(ptree,sl->sl_parent,&par.g_x,&par.g_y);
  95.     par.g_w = par_ptr->ob_width;
  96.     par.g_h = par_ptr->ob_height;
  97.  
  98.     if (sl->sl_vh)
  99.         max_pos = par_ptr->ob_height - ob_ptr->ob_height;
  100.     else
  101.         max_pos = par_ptr->ob_width - ob_ptr->ob_width;
  102.  
  103.     _beg_ctrl();
  104.     event.ev_mflags    = MU_BUTTON|MU_TIMER;
  105.     event.ev_mtlocount = sl->sl_speed;
  106.  
  107.     if (sl_mode==TRUE)
  108.         ob_draw_chg(info,obj,NULL,ptree[obj].ob_state | SELECTED,top);
  109.     else if (sl_mode==FALSE)
  110.     {
  111.         delta = sl->sl_page - 1;
  112.  
  113.         if (sl->sl_vh)
  114.         {
  115.             if (start_y<par.g_y + ob_ptr->ob_y)
  116.                 delta = -delta;
  117.         }
  118.         else if (start_x<(par.g_x+ob_ptr->ob_x))
  119.             delta = -delta;
  120.     }
  121.     else
  122.     {
  123.         event.ev_mflags = MU_BUTTON|MU_M1;
  124.         graf_mouse (FLAT_HAND,NULL);
  125.     }
  126.  
  127.     if (sl_mode>=FALSE)
  128.         evnt_timer(sl->sl_delay,0);
  129.  
  130.     do
  131.     {
  132.         if (sl_mode>=FALSE && sl->sl_mode==SL_LOG)
  133.         {
  134.             count++;
  135.             event.ev_mtlocount = sl->sl_speed/count;
  136.         }
  137.  
  138.         events = Event_Multi(&event,0);
  139.         event.ev_mm1x = event.ev_mmox;
  140.         event.ev_mm1y = event.ev_mmoy;
  141.  
  142.         if (max_pos>0)
  143.         {
  144.             prev = sl->sl_pos;
  145.  
  146.             if (sl_mode==TRUE)
  147.             {
  148.                 if (double_click)
  149.                 {
  150.                     if (sl->sl_dec<0)
  151.                         pos = 0;
  152.                     else
  153.                         pos = max_val;
  154.                 }
  155.                 else
  156.                 {
  157.                     switch (sl->sl_mode)
  158.                     {
  159.                     case SL_EXP:
  160.                         offset += ++index;
  161.                         break;
  162.                     case SL_LOG:
  163.                         offset = ++index;
  164.                         break;
  165.                     default:
  166.                         offset = 1;
  167.                     }
  168.  
  169.                     if (sl->sl_dec<0)
  170.                         pos = prev - offset;
  171.                     else
  172.                         pos = prev + offset;
  173.  
  174.                     if (pos<0 || pos>max_val)
  175.                         flag = TRUE;
  176.                 }
  177.             }
  178.             else if (sl_mode==FAIL)
  179.             {
  180.                 if (sl->sl_vh)
  181.                     pos = start_y + event.ev_mm1y;
  182.                 else
  183.                     pos = start_x + event.ev_mm1x;
  184.                 y = pos; y *= max_val; y /= max_pos;
  185.                 pos = (int) y;
  186.             }
  187.             else
  188.                 pos = prev + delta;
  189.             pos = min(max(pos,0),max_val);
  190.  
  191.             if (pos!=prev)
  192.             {
  193.                 reg GRECT area = par;
  194.                 reg int dif,n_pos,n_prev;
  195.  
  196.                 sl->sl_pos = pos;
  197.  
  198.                 y = pos;y *= max_pos;y /= max_val;
  199.                 n_pos = (int) y;
  200.  
  201.                 y = prev;y *= max_pos;y /= max_val;
  202.                 n_prev = (int) y;
  203.  
  204.                 dif = (n_pos < n_prev) ? (n_prev - n_pos + 1) : (n_pos - n_prev + 1);
  205.  
  206.                 if (sl->sl_vh)
  207.                 {
  208.                     area.g_h = dif;
  209.                     if (n_pos<n_prev)
  210.                         area.g_y += n_pos + ob_ptr->ob_height;
  211.                     else
  212.                         area.g_y += n_prev - 1;
  213.                     ob_ptr->ob_y = n_pos;
  214.                 }
  215.                 else
  216.                 {
  217.                     area.g_w = dif;
  218.                     if (n_pos<n_prev)
  219.                         area.g_x += n_pos + ob_ptr->ob_width;
  220.                     else
  221.                         area.g_x += n_prev - 1;
  222.                     ob_ptr->ob_x = n_pos;
  223.                 }
  224.  
  225.                 if (sl->sl_do)
  226.                     sl->sl_do(ob_ptr,pos,prev,max_val);
  227.  
  228.                 ob_draw_chg(info,sl->sl_slider,NULL,FAIL,top);
  229.                 ob_draw_chg(info,sl->sl_parent,&area,FAIL,top);
  230.  
  231.                 graf_set_slider(sl,ptree,GRAF_SET_ARROWS|GRAF_DRAW_SLIDER);
  232.             }
  233.         }
  234.     } while (!((events & MU_BUTTON) || flag || double_click || (sl_mode>0 && sl->sl_mode==SL_STEP)));
  235.  
  236.     if (sl_mode==TRUE)
  237.     {
  238.         if (sl->sl_dec<0)
  239.             sl->sl_dec = obj;
  240.         else
  241.             sl->sl_inc = obj;
  242.         ob_draw_chg(info,obj,NULL,ptree[obj].ob_state & (~SELECTED),top);
  243.         graf_set_slider(sl,ptree,GRAF_SET_ARROWS|GRAF_DRAW_SLIDER);
  244.     }
  245.     else
  246.         graf_mouse(ARROW, NULL);
  247.  
  248.     _no_click();
  249.     _end_ctrl();
  250. }
  251.  
  252. void graf_arrows(SLINFO *sl,OBJECT *tree,int show)
  253. {
  254.     graf_set_slider(sl,tree,(show) ? (GRAF_SET_ARROWS|GRAF_DRAW_SLIDER) : GRAF_SET_ARROWS);
  255. }
  256.  
  257. void graf_set_slider(SLINFO *sl,OBJECT *tree,int show)
  258. {
  259.     reg OBJECT *ob_ptr;
  260.  
  261.     if (sl->sl_info->di_flag==CLOSED)
  262.         show &= ~GRAF_DRAW_SLIDER;
  263.  
  264.     if (show & GRAF_SET_SIZE_POS)
  265.     {
  266.         reg OBJECT *par_ptr;
  267.         reg long y = sl->sl_pos,size;
  268.         reg int vh = sl->sl_vh,max_val = sl->sl_max - sl->sl_page;
  269.  
  270.         par_ptr = tree+sl->sl_parent;
  271.         ob_ptr = tree+sl->sl_slider;
  272.  
  273.         if (sl->sl_page>1)
  274.         {
  275.             size = (vh==VERT_SLIDER) ? par_ptr->ob_height : par_ptr->ob_width;
  276.  
  277.             if (max_val>0)
  278.             {
  279.                 size *= sl->sl_page;
  280.                 size /= sl->sl_max;
  281.             }
  282.             else if (vh==VERT_SLIDER)
  283.                 ob_ptr->ob_y = 0;
  284.             else
  285.                 ob_ptr->ob_x = 0;
  286.         }
  287.         else
  288.             size = (vh==VERT_SLIDER) ? ob_ptr->ob_height : ob_ptr->ob_width;
  289.  
  290.         if (size<gr_ch)
  291.             size = gr_ch;
  292.  
  293.         if (vh==VERT_SLIDER)
  294.         {
  295.             ob_ptr->ob_height = (int) size;
  296.  
  297.             if (max_val>0)
  298.             {
  299.                 y *= (par_ptr->ob_height - (int) size);
  300.                 y /= max_val;
  301.                 ob_ptr->ob_y = (int) y;
  302.             }
  303.         }
  304.         else
  305.         {
  306.             ob_ptr->ob_width = (int) size;
  307.  
  308.             if (max_val>0)
  309.             {
  310.                 y *= (par_ptr->ob_width - (int) size);
  311.                 y /= max_val;
  312.                 ob_ptr->ob_x = (int) y;
  313.             }
  314.         }
  315.  
  316.         if (show & GRAF_DRAW_SLIDER)
  317.             ob_draw_chg(sl->sl_info,sl->sl_parent,NULL,FAIL,FALSE);
  318.     }
  319.  
  320.     if (show & GRAF_SET_ARROWS)
  321.     {
  322.         if (sl->sl_dec>0)
  323.         {
  324.             reg int state;
  325.     
  326.             ob_ptr = tree+sl->sl_dec;
  327.             state = ob_ptr->ob_state;
  328.  
  329.             if (sl->sl_pos>0)
  330.                 state &= ~DISABLED;
  331.             else
  332.                 state |= DISABLED;
  333.     
  334.             if (state!=ob_ptr->ob_state)
  335.             {
  336.                 ob_ptr->ob_state = state;
  337.         
  338.                 if (show & GRAF_DRAW_SLIDER)
  339.                     ob_draw_chg(sl->sl_info,sl->sl_dec,NULL,FAIL,FALSE);
  340.             }
  341.         }
  342.         
  343.         if (sl->sl_inc>0)
  344.         {
  345.             reg int state;
  346.     
  347.             ob_ptr = tree+sl->sl_inc;
  348.             state = ob_ptr->ob_state;
  349.  
  350.             if (sl->sl_pos<(sl->sl_max - sl->sl_page))
  351.                 state &= ~DISABLED;
  352.             else
  353.                 state |= DISABLED;
  354.     
  355.             if (state!=ob_ptr->ob_state)
  356.             {
  357.                 ob_ptr->ob_state = state;
  358.         
  359.                 if (show & GRAF_DRAW_SLIDER)
  360.                     ob_draw_chg(sl->sl_info,sl->sl_inc,NULL,FAIL,FALSE);
  361.             }
  362.         }
  363.     }
  364. }
  365.  
  366. int graf_rt_rubberbox(int s_x,int s_y,GRECT *rect,int *r_w,int *r_h,void (*call_func)(int *new_rect))
  367. {
  368.     EVENT event;
  369.     reg int pxy[4],rect_xy[4];
  370.     reg int events,max_1,max_2,dif;
  371.  
  372.     if (!rc_inside(s_x,s_y,rect))
  373.         return(FALSE);
  374.  
  375.     rc_grect_to_array(rect,rect_xy);
  376.  
  377.     pxy[0] = s_x;
  378.     pxy[1] = s_y;
  379.  
  380.     max_1 = min(s_x - rect_xy[0],s_y - rect_xy[1]);
  381.     max_2 = min(rect_xy[2] - s_x,rect_xy[3] - s_y);
  382.  
  383.     _vdi_attr(MD_XOR,1,1);
  384.     vsl_type(x_handle,7);
  385.  
  386.     _beg_ctrl();    
  387.     graf_mouse(POINT_HAND,NULL);
  388.     _mouse_pos(&event.ev_mm1x,&event.ev_mm1y);
  389.  
  390.     event.ev_mflags = MU_BUTTON|MU_M1;
  391.     event.ev_mbclicks = event.ev_bmask = event.ev_mm1flags = 1;
  392.     event.ev_mbstate = 0;
  393.     event.ev_mm1width = event.ev_mm1height = event.ev_mmokstate = 1;
  394.     do
  395.     {
  396.         pxy[2] = max(event.ev_mm1x,rect_xy[0]);
  397.         Min(pxy+2,rect_xy[2]);
  398.  
  399.         pxy[3] = max(event.ev_mm1y,rect_xy[1]);
  400.         Min(pxy+3,rect_xy[3]);
  401.  
  402.         if (event.ev_mmokstate)
  403.         {
  404.             dif = pxy[2] - pxy[0];
  405.             dif = (dif>0) ? min(dif,max_2) : max(dif,-max_1);
  406.             pxy[2] = pxy[0] + dif;
  407.             pxy[3] = pxy[1] + dif;
  408.         }
  409.  
  410.         draw_rubber(pxy);
  411.  
  412.         if (call_func)
  413.             call_func(pxy);
  414.  
  415.         events = Event_Multi(&event,0);
  416.  
  417.         draw_rubber(pxy);
  418.     }
  419.     while(!(events & MU_BUTTON));
  420.  
  421.     vsl_udsty(x_handle,0x5555);
  422.     vsl_type(x_handle,1);
  423.  
  424.     graf_mouse(ARROW,NULL);
  425.     _end_ctrl();    
  426.  
  427.     *r_w = pxy[2] - pxy[0];
  428.     *r_h = pxy[3] - pxy[1];
  429.  
  430.     return(TRUE);
  431. }
  432.  
  433. void draw_rubber(reg int *pxy)
  434. {
  435.     graf_mouse(M_OFF,0l);
  436.     vsl_udsty(x_handle,(pxy[0] & 1) == (pxy[1] & 1) ? 21845 : (int) 43690L);
  437.     _line(pxy[0],pxy[1],pxy[0],pxy[3]);
  438.     
  439.     vsl_udsty(x_handle,(pxy[2] & 1) == (pxy[1] & 1) ? 21845 : (int) 43690L);
  440.     _line(pxy[2],pxy[1],pxy[2],pxy[3]);
  441.  
  442.     vsl_udsty(x_handle,(pxy[1] & 1) ? (int) 43690L : 21845);
  443.     _line(pxy[0],pxy[1],pxy[2],pxy[1]);
  444.     
  445.     vsl_udsty(x_handle,(pxy[3] & 1) ? (int) 43690L : 21845);
  446.     _line(pxy[0],pxy[3],pxy[2],pxy[3]);
  447.     graf_mouse(M_ON,0l);
  448. }
  449.